/*
 * 题目描述：银行窗口排队问题，但是客户不是同时到达的，每个窗口一次只能服务一个用户，其他的用户按照到达顺序在窗口外排队，每有一个
 *         窗口空闲就可以进入一个人
 *
 * 输入：N 顾客的数目 K 窗口的数目
 *      N行 顾客到达的时间（HH:MM:SS） 业务需要的时间（分钟）
 *
 * 输出：顾客的平均等待时间（注意，在8:00前到达的顾客必须等到8:00才能开始处理业务，在17:00后到达的顾客无法被服务）
 *
 * 思路：由于本题只考虑等待时间，所以当一个用户面临多个可用的窗口的时候，其实选择哪个窗口并不影响结果
 */

#include <iostream>
#include <vector>
#include <cstdio>
#include <algorithm>
#include <climits>
using namespace std;
int N,K;

struct Time{
    int hour;
    int minute;
    int second;
};

int operator-(struct Time t1, struct Time t2){
    int s1 = t1.hour * 60 * 60 + t1.minute * 60 + t1.second;
    int s2 = t2.hour * 60 * 60 + t2.minute * 60 + t2.second;
    return s1 - s2;
}

struct Customer{
    Time arrive_time;
    int cost;
};

struct Window{
    int time;
};
vector<Window> windows;
vector<Customer> customers;
Time base;

bool cmpArriveTime(Customer &c1, Customer &c2){
    return (c1.arrive_time - c2.arrive_time) < 0;
}

int main() {
    cin >> N >> K;
    Customer c;
    Time deadline;
    deadline.hour = 17;
    deadline.minute = 0;
    deadline.second = 0;
    Time opentime;
    opentime.hour = 8;
    opentime.minute = 0;
    opentime.second = 0;
    while(N--){
        scanf("%d:%d:%d %d",
              &c.arrive_time.hour,
              &c.arrive_time.minute,
              &c.arrive_time.second,
              &c.cost);
        c.cost *= 60;
        if (c.arrive_time - deadline > 0) {
            continue;
        }

        customers.push_back(c);
    }
    Window w;
    w.time = 8*3600;
    while(K--){
        windows.push_back(w);
    }
    sort(customers.begin(), customers.end(), cmpArriveTime);

    int clock = 0;
    int sum = 0;
    for(int i=0; i<customers.size(); i++){
        //时钟拨到当前用户到达的时刻
        clock = customers[i].arrive_time - base;
        int minValue = INT_MAX;
        int minIndex = -1;
        for(int j=0; j<windows.size(); j++){
            if(windows[j].time < minValue){
                minValue = windows[j].time;
                minIndex = j;
            }
        }
        sum += (clock > minValue) ? 0 : minValue - clock;
        windows[minIndex].time = max(minValue, clock) + customers[i].cost;
    }

    printf("%.1lf", 1.0 * sum / customers.size() / 60);
    return 0;
}